{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个实例中，我们使用tensorflow来实现一个简单的手写数字识别的网络，并用这个网络来做个\n",
    "简单的识别示例。\n",
    "\n",
    "首先导入一些用到的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:50.515650Z",
     "start_time": "2018-06-01T06:32:43.133728Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "/root/anaconda3/lib/python3.6/site-packages/matplotlib/font_manager.py:281: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment.\n",
      "  'Matplotlib is building the font cache using fc-list. '\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:39:48.304594Z",
     "start_time": "2018-06-01T04:55:17.674707Z"
    }
   },
   "source": [
    "先来看看数据长什么样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.075054Z",
     "start_time": "2018-06-01T06:32:50.518290Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-a34a30334354>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T05:49:40.128071Z",
     "start_time": "2018-06-01T05:49:40.123888Z"
    }
   },
   "source": [
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量，\n",
    "所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.695746Z",
     "start_time": "2018-06-01T06:32:51.077167Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f07106f3898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个bool类型的变量用于标识当前网络是否正在训练。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.706044Z",
     "start_time": "2018-06-01T06:32:51.698913Z"
    }
   },
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为我们输入的是图片展开后的一维向量，所以第一步就需要先把一维向量还原为二维的图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.719298Z",
     "start_time": "2018-06-01T06:32:51.707730Z"
    }
   },
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:07:36.530623Z",
     "start_time": "2018-06-01T06:07:36.522665Z"
    }
   },
   "source": [
    "接下来，我们定义第一个卷积层，使用6个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式选择valid，所以输出数据的宽高变为24x24,但是深度已经从原来的1变成了6。\n",
    "本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.764292Z",
     "start_time": "2018-06-01T06:32:51.721295Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来进行stride为2的最大池化，池化后，输出深度不变，但是长宽减半，所以输出变成了12x12,深度6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.774112Z",
     "start_time": "2018-06-01T06:32:51.766784Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:10:16.678485Z",
     "start_time": "2018-06-01T06:10:16.671472Z"
    }
   },
   "source": [
    "接下来，我们定义第二个卷积层，使用16个5X5的卷积核对输入数据进行卷积，\n",
    "padding方式还是选择valid，输出8x8,深度为16，本层卷积的激活函数为relu。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.805912Z",
     "start_time": "2018-06-01T06:32:51.776959Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再进行一次stride为2的最大池化，输出为4x4,深度16。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.814748Z",
     "start_time": "2018-06-01T06:32:51.807560Z"
    }
   },
   "outputs": [],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "池化后的数据是3维的，这里做一个拉平的操作，将3维数据展开到1维，然后送入两层全连接，全连接隐层中神经元个数分别为120，84。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.856740Z",
     "start_time": "2018-06-01T06:32:51.817287Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py:1624: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:17:39.880958Z",
     "start_time": "2018-06-01T06:17:39.869797Z"
    }
   },
   "source": [
    "###### 对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout，\n",
    "所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:51.913419Z",
     "start_time": "2018-06-01T06:32:51.860766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-11-413a88f1eb86>:3: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits,\n",
    "这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为0.3。\n",
    "\n",
    ">试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.084738Z",
     "start_time": "2018-06-01T06:32:51.915376Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-12-3c77ec77605a>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:25:56.449132Z",
     "start_time": "2018-06-01T06:25:56.438340Z"
    }
   },
   "source": [
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布，\n",
    "要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:39:50.010829Z",
     "start_time": "2018-06-01T06:39:49.997501Z"
    }
   },
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:32:52.127795Z",
     "start_time": "2018-06-01T06:32:52.103115Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:35:22.270272Z",
     "start_time": "2018-06-01T06:33:18.829198Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.4479, the validation accuracy is 0.9086\n",
      "after 200 training steps, the loss is 0.249558, the validation accuracy is 0.9528\n",
      "after 300 training steps, the loss is 0.104332, the validation accuracy is 0.9558\n",
      "after 400 training steps, the loss is 0.355294, the validation accuracy is 0.973\n",
      "after 500 training steps, the loss is 0.308514, the validation accuracy is 0.9768\n",
      "after 600 training steps, the loss is 0.160169, the validation accuracy is 0.978\n",
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/python/training/saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.129407, the validation accuracy is 0.9746\n",
      "after 800 training steps, the loss is 0.0419678, the validation accuracy is 0.9824\n",
      "after 900 training steps, the loss is 0.113623, the validation accuracy is 0.9766\n",
      "after 1000 training steps, the loss is 0.164979, the validation accuracy is 0.9856\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9803\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-01T06:58:16.766415Z",
     "start_time": "2018-06-01T06:58:15.918700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /root/anaconda3/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0708419dd8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
